from __future__ import annotations

import inspect
import sys
from importlib.metadata import EntryPoint
from typing import TYPE_CHECKING, Callable

# imports
import pytest  # used for our unit tests
from xarray.backends.plugins import detect_parameters

# unit tests

# ------------------- Basic Test Cases -------------------


def test_no_parameters():
    # Function with no parameters
    def f():
        return 1

    codeflash_output = detect_parameters(f)  # 10.4μs -> 11.6μs (9.94% slower)


def test_single_parameter():
    # Function with one parameter
    def f(a):
        return a

    codeflash_output = detect_parameters(f)  # 16.2μs -> 16.4μs (1.16% slower)


def test_multiple_parameters():
    # Function with multiple parameters
    def f(a, b, c):
        return a + b + c

    codeflash_output = detect_parameters(f)  # 17.4μs -> 17.3μs (0.712% faster)


def test_default_parameters():
    # Function with default values
    def f(a, b=2, c=3):
        return a + b + c

    codeflash_output = detect_parameters(f)  # 18.8μs -> 18.5μs (1.28% faster)


def test_keyword_only_parameters():
    # Function with keyword-only parameters
    def f(a, *, b, c=5):
        return a + b + c

    codeflash_output = detect_parameters(f)  # 18.8μs -> 18.7μs (0.653% faster)


def test_self_is_ignored():
    # Method with 'self' as first parameter
    class C:
        def f(self, a, b):
            return a + b

    codeflash_output = detect_parameters(C.f)  # 18.2μs -> 18.4μs (1.40% slower)


def test_class_method_with_cls():
    # Class method with 'cls' as first parameter
    class C:
        @classmethod
        def f(cls, a, b):
            return a + b

    codeflash_output = detect_parameters(C.f)  # 25.6μs -> 24.9μs (2.46% faster)


def test_static_method():
    # Static method (no self/cls)
    class C:
        @staticmethod
        def f(a, b):
            return a + b

    codeflash_output = detect_parameters(C.f)  # 17.1μs -> 16.6μs (2.89% faster)


# ------------------- Edge Test Cases -------------------


def test_raises_on_varargs():
    # Function with *args should raise TypeError
    def f(a, *args):
        return a

    with pytest.raises(TypeError) as excinfo:
        detect_parameters(f)  # 18.6μs -> 18.1μs (3.01% faster)


def test_raises_on_varkw():
    # Function with **kwargs should raise TypeError
    def f(a, **kwargs):
        return a

    with pytest.raises(TypeError) as excinfo:
        detect_parameters(f)  # 18.4μs -> 18.4μs (0.136% slower)


def test_raises_on_both_varargs_and_varkw():
    # Function with both *args and **kwargs
    def f(a, *args, **kwargs):
        return a

    with pytest.raises(TypeError) as excinfo:
        detect_parameters(f)  # 19.7μs -> 20.1μs (1.90% slower)


def test_self_only_method():
    # Method with only 'self'
    class C:
        def f(self):
            pass

    codeflash_output = detect_parameters(C.f)  # 15.5μs -> 15.7μs (1.13% slower)


def test_self_and_varargs():
    # Method with 'self' and *args
    class C:
        def f(self, *args):
            pass

    with pytest.raises(TypeError):
        detect_parameters(C.f)  # 19.1μs -> 18.5μs (3.23% faster)


def test_self_and_varkw():
    # Method with 'self' and **kwargs
    class C:
        def f(self, **kwargs):
            pass

    with pytest.raises(TypeError):
        detect_parameters(C.f)  # 18.9μs -> 18.6μs (1.76% faster)


def test_annotations_and_defaults():
    # Function with annotations and defaults
    def f(a: int, b: str = "x", *, c: float = 1.2):
        pass

    codeflash_output = detect_parameters(f)  # 20.1μs -> 19.3μs (4.21% faster)


def test_positional_only_parameters():
    # Function with positional-only parameters (Python 3.8+)
    import sys

    if sys.version_info >= (3, 8):
        exec("def f(a, b, /, c, d): pass\n" "result = detect_parameters(f)")


def test_parameter_named_self_not_first():
    # Function with a parameter named 'self' not in first position
    def f(a, self, b):
        return a + b

    codeflash_output = detect_parameters(f)  # 17.6μs -> 17.6μs (0.387% faster)


def test_parameter_named_self_only_ignored_if_first():
    # Only the first parameter named 'self' is ignored
    def f(self, self2, self3):
        return self2 + self3

    codeflash_output = detect_parameters(f)  # 17.3μs -> 17.6μs (1.86% slower)


def test_parameter_named_self_in_middle():
    # Parameter named 'self' in the middle should not be ignored
    def f(a, self, b):
        return a + b

    codeflash_output = detect_parameters(f)  # 17.9μs -> 16.9μs (5.79% faster)


def test_parameter_named_self_and_cls():
    # Both 'self' and 'cls' as parameters
    def f(self, cls, a):
        return a

    codeflash_output = detect_parameters(f)  # 17.4μs -> 17.4μs (0.126% slower)


def test_many_parameters():
    # Function with a large number of parameters (1000)
    param_names = [f"a{i}" for i in range(1000)]
    param_str = ", ".join(param_names)
    # Dynamically create a function with 1000 parameters
    ns = {}
    exec(f"def f({param_str}): pass", ns)
    f = ns["f"]
    codeflash_output = detect_parameters(f)  # 869μs -> 790μs (10.0% faster)


def test_large_class_with_many_methods():
    # Class with many methods, each with many parameters
    class C:
        pass

    for i in range(10):
        param_names = [f"a{j}" for j in range(100)]
        param_str = ", ".join(["self"] + param_names)
        exec(f"def f{i}(self, {', '.join(param_names)}): pass", {}, locals())
        setattr(C, f"f{i}", locals()[f"f{i}"])
    for i in range(10):
        method = getattr(C, f"f{i}")
        expected = tuple(f"a{j}" for j in range(100))
        codeflash_output = detect_parameters(method)  # 908μs -> 839μs (8.23% faster)


def test_large_number_of_default_parameters():
    # Function with many parameters with defaults
    param_names = [f"d{i}" for i in range(500)]
    param_str = ", ".join(f"{n}=None" for n in param_names)
    ns = {}
    exec(f"def f({param_str}): pass", ns)
    f = ns["f"]
    codeflash_output = detect_parameters(f)  # 483μs -> 442μs (9.08% faster)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from __future__ import annotations

import inspect  # used to create test functions with different signatures
import sys
from typing import TYPE_CHECKING, Callable

# imports
import pytest  # used for our unit tests
from xarray.backends.plugins import detect_parameters

# unit tests

# --- BASIC TEST CASES ---


def test_no_parameters():
    # Function with no parameters
    def f():
        return 42

    codeflash_output = detect_parameters(f)  # 10.3μs -> 11.1μs (7.33% slower)


def test_single_parameter():
    # Function with one parameter
    def f(x):
        return x

    codeflash_output = detect_parameters(f)  # 15.8μs -> 15.6μs (1.41% faster)


def test_multiple_parameters():
    # Function with multiple parameters
    def f(a, b, c):
        return a + b + c

    codeflash_output = detect_parameters(f)  # 17.8μs -> 17.3μs (3.00% faster)


def test_default_parameters():
    # Function with default values
    def f(a, b=2, c=3):
        return a + b + c

    codeflash_output = detect_parameters(f)  # 18.9μs -> 18.3μs (3.25% faster)


def test_keyword_only_parameters():
    # Function with keyword-only arguments
    def f(a, *, b, c=5):
        return a + b + c

    codeflash_output = detect_parameters(f)  # 18.6μs -> 19.0μs (2.31% slower)


def test_positional_only_parameters():
    # Function with positional-only arguments (Python 3.8+)
    def f(a, b, /, c, d=4):
        return a + b + c + d

    codeflash_output = detect_parameters(f)  # 20.1μs -> 19.5μs (3.29% faster)


def test_mixed_parameter_types():
    # Function with positional, keyword-only, and default parameters
    def f(a, b=2, *, c, d=3):
        return a + b + c + d

    codeflash_output = detect_parameters(f)  # 20.1μs -> 19.9μs (0.931% faster)


def test_method_removes_self():
    # Method should not include 'self'
    class MyClass:
        def my_method(self, a, b):
            return a + b

    codeflash_output = detect_parameters(
        MyClass.my_method
    )  # 18.3μs -> 18.4μs (0.830% slower)


def test_classmethod_removes_self():
    # Classmethod should not include 'cls'
    class MyClass:
        @classmethod
        def my_classmethod(cls, a, b):
            return a + b

    codeflash_output = detect_parameters(
        MyClass.my_classmethod
    )  # 25.2μs -> 25.2μs (0.123% slower)


def test_staticmethod():
    # Staticmethod should include all parameters
    class MyClass:
        @staticmethod
        def my_staticmethod(a, b):
            return a + b

    codeflash_output = detect_parameters(
        MyClass.my_staticmethod
    )  # 16.6μs -> 16.5μs (0.800% faster)


# --- EDGE TEST CASES ---


def test_raises_on_varargs():
    # Function with *args should raise TypeError
    def f(a, *args):
        pass

    with pytest.raises(TypeError, match=r"\*args and \*\*kwargs is not supported"):
        detect_parameters(f)  # 18.4μs -> 18.3μs (0.399% faster)


def test_raises_on_kwargs():
    # Function with **kwargs should raise TypeError
    def f(a, **kwargs):
        pass

    with pytest.raises(TypeError, match=r"\*args and \*\*kwargs is not supported"):
        detect_parameters(f)  # 18.6μs -> 18.1μs (2.73% faster)


def test_raises_on_both_varargs_and_kwargs():
    # Function with both *args and **kwargs should raise TypeError
    def f(*args, **kwargs):
        pass

    with pytest.raises(TypeError, match=r"\*args and \*\*kwargs is not supported"):
        detect_parameters(f)  # 18.2μs -> 19.5μs (6.42% slower)


def test_function_named_self():
    # Function with a parameter named 'self' (should not exclude it unless it's a method)
    def f(self, a):
        pass

    codeflash_output = detect_parameters(f)  # 16.8μs -> 17.1μs (1.57% slower)


def test_method_with_self_and_varargs():
    # Method with *args should raise TypeError
    class MyClass:
        def my_method(self, *args):
            pass

    with pytest.raises(TypeError):
        detect_parameters(MyClass.my_method)  # 19.1μs -> 18.5μs (3.36% faster)


def test_method_with_self_and_kwargs():
    # Method with **kwargs should raise TypeError
    class MyClass:
        def my_method(self, **kwargs):
            pass

    with pytest.raises(TypeError):
        detect_parameters(MyClass.my_method)  # 19.0μs -> 18.9μs (0.502% faster)


def test_classmethod_with_cls_and_varargs():
    # Classmethod with *args should raise TypeError
    class MyClass:
        @classmethod
        def my_classmethod(cls, *args):
            pass

    with pytest.raises(TypeError):
        detect_parameters(MyClass.my_classmethod)  # 25.0μs -> 25.6μs (2.24% slower)


def test_lambda_function():
    # Lambda function with explicit parameters
    f = lambda x, y: x + y
    codeflash_output = detect_parameters(f)  # 16.8μs -> 16.6μs (0.859% faster)


def test_lambda_function_with_varargs():
    # Lambda function with *args should raise TypeError
    f = lambda x, *args: x
    with pytest.raises(TypeError):
        detect_parameters(f)  # 18.4μs -> 18.7μs (1.41% slower)


def test_lambda_function_with_kwargs():
    # Lambda function with **kwargs should raise TypeError
    f = lambda x, **kwargs: x
    with pytest.raises(TypeError):
        detect_parameters(f)  # 18.4μs -> 18.5μs (0.724% slower)


def test_function_with_annotations():
    # Function with type annotations
    def f(a: int, b: str) -> bool:
        return True

    codeflash_output = detect_parameters(f)  # 17.3μs -> 17.7μs (2.12% slower)


def test_function_with_positional_and_keyword_only():
    # Function with positional-only and keyword-only parameters
    def f(a, /, b, *, c):
        return a + b + c

    codeflash_output = detect_parameters(f)  # 18.7μs -> 18.1μs (3.18% faster)


# --- LARGE SCALE TEST CASES ---


def test_large_number_of_parameters():
    # Function with many parameters (up to 1000)
    def make_large_func(n):
        # Dynamically create a function with n parameters
        code = "def f({}): return 0".format(", ".join(f"x{i}" for i in range(n)))
        namespace = {}
        exec(code, namespace)
        return namespace["f"]

    N = 1000
    f = make_large_func(N)
    expected = tuple(f"x{i}" for i in range(N))
    codeflash_output = detect_parameters(f)  # 864μs -> 791μs (9.23% faster)


def test_large_number_of_default_parameters():
    # Function with many default parameters
    def make_large_func_with_defaults(n):
        code = "def f({}): return 0".format(", ".join(f"x{i}=0" for i in range(n)))
        namespace = {}
        exec(code, namespace)
        return namespace["f"]

    N = 500
    f = make_large_func_with_defaults(N)
    expected = tuple(f"x{i}" for i in range(N))
    codeflash_output = detect_parameters(f)  # 481μs -> 439μs (9.57% faster)


def test_large_number_of_parameters_with_mix():
    # Function with a mix of positional, default, and keyword-only parameters
    def make_large_func_mix(n_pos, n_def, n_kw):
        pos = ", ".join(f"p{i}" for i in range(n_pos))
        defs = ", ".join(f"d{i}=0" for i in range(n_def))
        kw = ", ".join(f"k{i}" for i in range(n_kw))
        code = f"def f({pos}, {defs}, *, {kw}): return 0"
        namespace = {}
        exec(code, namespace)
        return namespace["f"]

    N_POS, N_DEF, N_KW = 100, 100, 100
    f = make_large_func_mix(N_POS, N_DEF, N_KW)
    expected = tuple(
        [f"p{i}" for i in range(N_POS)]
        + [f"d{i}" for i in range(N_DEF)]
        + [f"k{i}" for i in range(N_KW)]
    )
    codeflash_output = detect_parameters(f)  # 286μs -> 261μs (9.67% faster)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.